home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 2000 October / Software of the Month - Ultimate Collection Shareware 277.iso / pc / PROGRAMS / UTILITY / WINLINUX / DATA1.CAB / programs_-_include / ASM-SPAR.{_6 / IO.H < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-17  |  4.0 KB  |  166 lines
  1. /* $Id: io.h,v 1.18 1998/09/21 05:07:17 jj Exp $ */
  2. #ifndef __SPARC_IO_H
  3. #define __SPARC_IO_H
  4.  
  5. #include <linux/kernel.h>
  6. #include <linux/types.h>
  7.  
  8. #include <asm/page.h>      /* IO address mapping routines need this */
  9. #include <asm/system.h>
  10.  
  11. /*
  12.  * Defines for io operations on the Sparc. Whether a memory access is going
  13.  * to i/o sparc is encoded in the pte. The type bits determine whether this
  14.  * is i/o sparc, on board memory, or VME space for VME cards. I think VME
  15.  * space only works on sun4's
  16.  */
  17.  
  18. #define virt_to_bus virt_to_phys
  19.  
  20. extern __inline__ unsigned  flip_dword (unsigned d) {
  21.         return ((d&0xff)<<24) | (((d>>8)&0xff)<<16) | (((d>>16)&0xff)<<8)| ((d>>24)&0xff);
  22. }
  23.  
  24. extern __inline__ unsigned short flip_word (unsigned short d) {
  25.         return ((d&0xff) << 8) | ((d>>8)&0xff);
  26. }
  27.  
  28. extern __inline__ unsigned long readb(unsigned long addr)
  29. {
  30.        return *(volatile unsigned char*)addr;
  31. }
  32.  
  33. extern __inline__ unsigned long readw(unsigned long addr)
  34. {
  35.        return flip_word(*(volatile unsigned short*)addr);
  36. }
  37.  
  38. extern __inline__ unsigned long readl(unsigned long addr)
  39. {
  40.        return flip_dword(*(volatile unsigned long*)addr);
  41. }
  42.  
  43. extern __inline__ void writeb(unsigned short b, unsigned long addr)
  44. {
  45.        *(volatile unsigned char*)addr = b;
  46. }
  47.  
  48. extern __inline__ void writew(unsigned short b, unsigned long addr)
  49. {
  50.        *(volatile unsigned short*)addr = flip_word(b);
  51. }
  52.  
  53. extern __inline__ void writel(unsigned int b, unsigned long addr)
  54. {
  55.         *(volatile unsigned long*)addr = flip_dword(b);
  56. }
  57.  
  58. extern __inline__ unsigned long inb_local(unsigned long addr)
  59. {
  60.        return readb(addr);
  61. }
  62.  
  63. extern __inline__ void outb_local(unsigned char b, unsigned long addr)
  64. {
  65.        return writeb(b,addr);
  66. }
  67.  
  68. extern __inline__ unsigned long inb(unsigned long addr)
  69. {
  70.        return readb(addr);
  71. }
  72.  
  73. extern __inline__ unsigned long inw(unsigned long addr)
  74. {
  75.        return readw(addr);
  76. }
  77.  
  78. extern __inline__ unsigned long inl(unsigned long addr)
  79. {
  80.        return readl(addr);
  81. }
  82.  
  83. extern __inline__ void outb(unsigned char b, unsigned long addr)
  84. {
  85.        return writeb(b,addr);
  86. }
  87.  
  88. extern __inline__ void outw(unsigned short b, unsigned long addr)
  89. {
  90.        return writew(b,addr);
  91. }
  92.  
  93. extern __inline__ void outl(unsigned int b, unsigned long addr)
  94. {
  95.        return writel(b,addr);
  96. }
  97.  
  98. #define inb_p inb
  99. #define outb_p outb
  100.  
  101. extern void sun4c_mapioaddr(unsigned long, unsigned long, int bus_type, int rdonly);
  102. extern void srmmu_mapioaddr(unsigned long, unsigned long, int bus_type, int rdonly);
  103.  
  104. extern __inline__ void mapioaddr(unsigned long physaddr, unsigned long virt_addr,
  105.                  int bus, int rdonly)
  106. {
  107.     switch(sparc_cpu_model) {
  108.     case sun4c:
  109.     case sun4:
  110.         sun4c_mapioaddr(physaddr, virt_addr, bus, rdonly);
  111.         break;
  112.     case sun4m:
  113.     case sun4d:
  114.     case sun4e:
  115.         srmmu_mapioaddr(physaddr, virt_addr, bus, rdonly);
  116.         break;
  117.     default:
  118.         printk("mapioaddr: Trying to map IO space for unsupported machine.\n");
  119.         printk("mapioaddr: sparc_cpu_model = %d\n", sparc_cpu_model);
  120.         printk("mapioaddr: Halting...\n");
  121.         halt();
  122.     };
  123.     return;
  124. }
  125.  
  126. extern void srmmu_unmapioaddr(unsigned long virt);
  127. extern void sun4c_unmapioaddr(unsigned long virt);
  128.  
  129. extern __inline__ void unmapioaddr(unsigned long virt_addr)
  130. {
  131.     switch(sparc_cpu_model) {
  132.     case sun4c:
  133.     case sun4:
  134.         sun4c_unmapioaddr(virt_addr);
  135.         break;
  136.     case sun4m:
  137.     case sun4d:
  138.     case sun4e:
  139.         srmmu_unmapioaddr(virt_addr);
  140.         break;
  141.     default:
  142.         printk("unmapioaddr: sparc_cpu_model = %d, halt...\n", sparc_cpu_model);
  143.         halt();
  144.     };
  145.     return;
  146. }
  147.  
  148. extern void *sparc_alloc_io (u32 pa, void *va, int sz, char *name, u32 io, int rdonly);
  149. extern void sparc_free_io (void *vaddr, int sz);
  150. extern void *_sparc_dvma_malloc (int sz, char *name);
  151.  
  152. /* Returns CPU visible address, dvmaaddr_p is a pointer to where
  153.  * the DVMA visible (ie. SBUS/PSYCO+PCI) address should be stored.
  154.  */
  155. static __inline__ void *sparc_dvma_malloc(int size, char *name, __u32 *dvmaaddr_p)
  156. {
  157.     void *cpuaddr = _sparc_dvma_malloc(size, name);
  158.     *dvmaaddr_p = (__u32) cpuaddr;
  159.     return cpuaddr;
  160. }
  161.  
  162. #define virt_to_phys(x) __pa((unsigned long)(x))
  163. #define phys_to_virt(x) __va((unsigned long)(x))
  164.  
  165. #endif /* !(__SPARC_IO_H) */
  166.